package com.ufcg.lvc.server;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.regex.Pattern;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.ufcg.lvc.client.GreetingServiceCRUD;

/**
 *
 * The server side implementation of the RPC service.
 *
 * @author Larissa Costa
 *
 */
@SuppressWarnings("serial")
public class GreetingServiceCRUDImpl extends RemoteServiceServlet implements
		GreetingServiceCRUD {

	private Conexao conexaoUsuario = new Conexao().getNewConexao();
	
	//ok
	public String cadastraUsuarioSenha(String usuario, String senha, String nome, String email) {

		/** Verifica se o usuario e a senha estao validos */
		if ((usuario.trim().length() >= 3) & (senha.trim().length() >= 3)) {
			try {
				/** Verifica se o login esta disponivel */
				String sql = "select * from USUARIO where LOGIN like '"	+ usuario + "';";
				conexaoUsuario.executaConsulta(sql);

				/** Se achar o valor */
				if (DataBase.getInstance().procuraBD("usuario", "login", usuario)) {
					return "Erro: Login não disponível.\nJá existe um usuário com esse login.\nEscolha outro nome de login.";
				}

				/** Se o login estiver disponivel, o cadastra o usuario */
				else {
					String sql2 = "select max(usuario_id) from usuario";
					conexaoUsuario.executaConsulta(sql2);
					if (conexaoUsuario.getResultSet().next()) {
						int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1;
						String sql3 = "insert into usuario values ("+id+", '"+usuario+"','"+senha+"', '"+nome+"','"+email+"')";
						conexaoUsuario.executaUpdate(sql3);
						System.out.println("Novo usuário salvo! nome: " + nome + " - id: " + id);
						return "Usuário ca dastrado!";
					}else {
						return "Erro: Sistema em manutenção";
					}
					
				}
			} catch (Exception erro) {
				return "Erro: Não foi possível cadastrar o usuário.\n" + erro;
			}
		}
		/** Loing e/ou senha invalidos */
		else {
			return "Erro: Login e senha devem possuir pelo menos três caracteres.";
		}
	}
	
	public String conexao(String usuario, String senha) {
		try {
			if (DataBase.getInstance().procuraBD("usuario", "login", usuario, "senha", senha) == true) {
				return "Usuário e senha válidos.";
			}
			else {
				return "Erro: Usuário e senha inválidos.";
			}
		} catch (Exception erro) {
			return "Erro: Não foi possível acessar o banco de dados\n" + erro;
		}
	}

	//ok
	@Override
	public Boolean deletarLinha(String tabela, String chave, String valor, String Id_usuario) {

		try {
			String sql = "DELETE FROM " + tabela + " where " + chave + "='"	+ valor + "' and usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao excluir linha: " + erro);
			return false;
		}
	}
	
	//ok
	@Override
	public Boolean deletarQuestaoDoModeloDeProva (String modeloID, String tituloQuestao, String valorQuestao, String Id_usuario) {
		try {
			String sql = "select * from questaodomodelodeprova qmp, modelodeprova m, questao q where qmp.modelodeprova_id = "+modeloID+" and qmp.modelodeprova_id = m.modelodeprova_id and q.titulo = '"+tituloQuestao+"' and qmp.valor = '"+valorQuestao+"';";
			System.out.println(sql);
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				String sqlD = "delete from questaodomodelodeprova where questao_id = "+getIDQuestao(tituloQuestao, Id_usuario)+" and modelodeprova_id = "+modeloID+" and valor = '"+valorQuestao+"';";
				System.out.println(sqlD);
				conexaoUsuario.executaUpdate(sqlD);
				return true;
			}
		} catch (Exception erro) {
			System.out.println("Erro deletar questão do modelo de prova: " + erro);
		}
		return false;
	
	}

	private List<List<String>> extraiGabarito(String gabarito){
		List<String> corretas = new ArrayList<>();
		List<String> valores = new ArrayList<>();
		List<List<String>> lista = new ArrayList<>();
		
		String[] aux = gabarito.split(Pattern.quote("*")); // separa as questoes
		for (int i = 0; i < aux.length; i++) {
			corretas.add(gabarito.split(Pattern.quote("*"))[i].split(Pattern.quote("^"))[0]);
			valores.add(gabarito.split(Pattern.quote("*"))[i].split(Pattern.quote("^"))[1]);
		}
		
		lista.add(corretas);
		lista.add(valores);
		return lista;
	}

	//ok
	@Override
	public String gerarLink(String titulo, String Id_usuario){
		String login = Id_usuario;
		return login+"_"+titulo+".zip";
	}


	//ok
	@Override
	public List<List<String>> getAlternativas(String titulo, String Id_usuario) {
		
		List<List<String>> listaListas = new ArrayList<>();
		for (int i = 0; i < 3; i++) {
			listaListas.add((List<String>) new ArrayList<String>());
		}
		try {
			String sql = "select questao_id from questao where usuario_id = " + Id_usuario + " and titulo = '"+titulo+"';";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				String questao_id = conexaoUsuario.getResultSet().getArray(1).toString();
				String sql2 = "select enunciado, correta, imagem_id from ALTERNATIVA where questao_id = " + questao_id + ";";
				conexaoUsuario.executaConsulta(sql2);
				while (conexaoUsuario.getResultSet().next()) {
					listaListas.get(0).add(	conexaoUsuario.getResultSet().getArray(1).toString());//enunciados
					listaListas.get(1).add(	conexaoUsuario.getResultSet().getArray(2).toString());//corretas
					listaListas.get(2).add(	conexaoUsuario.getResultSet().getArray(3).toString());//imagens_ids
				}	
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar alternativas: " + erro);
		}
		return listaListas;
	}
	
	//ok
	@Override
	public String getAlunoDaProva(String tituloProva, String nomeTurma, String Id_usuario) {
		try {
			String turma_id = getIDTurma(nomeTurma, Id_usuario);
			String sql = "select a.nome from prova p, aluno a where p.titulo = '"+tituloProva+"' and  a.aluno_id = p.aluno_id and p.turma_id = "+turma_id+";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar nome do aluno da prova: " + erro);
		}
		return "-1";
	}

//	private String getDataAtual(){
//        Date data = new Date(System.currentTimeMillis());    
//        DateFormat formatarDate = new SimpleDateFormat("dd.MM.yyyy");   
//        return(formatarDate.format(data));  
//    }
//			
//	private String getHoraAtual(){
//    	GregorianCalendar data = new GregorianCalendar();
//    	return(data.get(Calendar.HOUR_OF_DAY)+":"+data.get(Calendar.MINUTE)+":"+data.get(Calendar.SECOND));      
//    }
	
	//ok
	@Override
	public List<List<String>> getAlunos(String Id_usuario) {

		List<List<String>> listaListas = new ArrayList<>();
		for (int i = 0; i < 3; i++) {
			listaListas.add((List<String>) new ArrayList<String>());
		}
		try {
			String sql = "SELECT a.nome, ia.matricula, i.nome FROM instituicao_aluno ia, aluno a, instituicao i " +
					"WHERE ia.aluno_id = a.aluno_id and ia.instituicao_id = i.instituicao_id and a.usuario_id = "+ Id_usuario +"  ORDER BY a.nome"; 
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.get(0).add(	conexaoUsuario.getResultSet().getArray(1).toString());
				listaListas.get(1).add(	conexaoUsuario.getResultSet().getArray(2).toString());
				listaListas.get(2).add(	conexaoUsuario.getResultSet().getArray(3).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar aluno: " + erro);
		}
		return listaListas;
	}
	
	//ok
	@Override
	public List<String> getAlunosDaTurma(String turma, String Id_usuario) {

		List<String> listaListas = new ArrayList<>();
		String id_turma = getIDTurma(turma, Id_usuario);
		try {
			String sql = "select distinct a.nome from aluno a, aluno_turma t where t.turma_id = " + id_turma+"  and t.aluno_id = a.aluno_id;"; 
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.add(	conexaoUsuario.getResultSet().getArray(1).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar aluno: " + erro);
		}
		return listaListas;
	}
	
	//ok
	@Override
	public String getCabecalhoInstituicao(String nome, String Id_usuario) {

		try {
			String sql = "select cabecalho from instituicao where nome = '"+nome+"' and usuario_id = "+ Id_usuario;
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar cabecalho da instituicao: " + erro);
		}
		return "-1";
	}
	
	//ok
	@Override
	public ArrayList<String> getDadosUsuario(String Id_usuario) {

		ArrayList<String> lista = new ArrayList<String>();
		try {
			String sql = "select nome, email, login from usuario where usuario_id = "+ Id_usuario+";"; 
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				lista.add(0, conexaoUsuario.getResultSet().getArray(1).toString());
				lista.add(1, conexaoUsuario.getResultSet().getArray(2).toString());
				lista.add(2, conexaoUsuario.getResultSet().getArray(3).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar nome do usuário: " + erro);
		}
		return lista;
	}
	
	public List<String> getEnunciadoQuestaoDoModeloDeProva(String modelo_id) {

		List<String> saida= new ArrayList<>();
		String texto = "\r\n";
		String gabarito= "";
				
		List<String> l = new ArrayList<>();
		
		try {
			String sql = "SELECT qmp.valor, q.enunciado, q.tipo, q.questao_id FROM questao q, questaodomodelodeprova qmp WHERE q.questao_id = qmp.questao_id and qmp.modelodeprova_id = "+modelo_id+";";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				if (conexaoUsuario.getResultSet().getArray(3).toString().equalsIgnoreCase("Objetiva")){
					String s = conexaoUsuario.getResultSet().getArray(1).toString() + "*"+ // valor  
							   "O" 													+ "*"+ // tipo
							   conexaoUsuario.getResultSet().getArray(4).toString() + "*"+ // id 
							   conexaoUsuario.getResultSet().getArray(2).toString();	   // enunciado
					l.add(s);
				} else{
					String s = conexaoUsuario.getResultSet().getArray(1).toString() + "*"+  // valor  
							   "S" 													+ "*"+ 	// tipo 
							   conexaoUsuario.getResultSet().getArray(4).toString() + "*"+  // id 
							   conexaoUsuario.getResultSet().getArray(2).toString();		// enunciado
					l.add(s);
				}
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar enunciados das questões do modelo de prova: " + erro);
		}
		Collections.shuffle(l);
		
		String qcorreta = "*";
		for (int i = 0; i < l.size(); i++) { // para cada questao do modelo
			String[] q = l.get(i).split(Pattern.quote("*"));  
			
			String qvalor = q[0];
			String qtipo = q[1];
			String qid = q[2];
			String qenunciado = q[3];	
			String qtextoAlternativa = "";
			
			texto+="\r\n"+(i+1) + " - "+ qenunciado + "\r\n\r\n";
			if (qtipo.equalsIgnoreCase("O")){
				String[] qalternativa = getEnunciadosAlternativasQuestao(qid, modelo_id);
				qtextoAlternativa = qalternativa[1] ;
				if (qalternativa[0].equals("")) {
					qcorreta += "#^"+ qvalor +"*";
				} else {
					qcorreta += qalternativa[0]+"^"+ qvalor +"*";
				}
				texto += qtextoAlternativa;
			} else {
				qcorreta += "#^"+ qvalor +"*";
			}
		}
		gabarito += qcorreta;
		saida.add(texto);
		saida.add(gabarito);
		return saida;
	}
	
	public String[] getEnunciadosAlternativasQuestao(String questao_id, String modelo_id) {

		List<String> l1 = new ArrayList<>();
		String texto = "";
		String[] a1 = {"correta","texto"};
		String correta = "";
		String[] letras = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p"};
		
		try {
			String sql_ ="select a.enunciado, qmp.valor, a.correta from questao q, questaodomodelodeprova qmp, alternativa a where qmp.modelodeprova_id = "+modelo_id+" and qmp.questao_id = "+questao_id+" and q.questao_id = "+questao_id+" and a.questao_id = "+questao_id+";";
			conexaoUsuario.executaConsulta(sql_);
			while (conexaoUsuario.getResultSet().next()) {
				if (conexaoUsuario.getResultSet().getArray(3).toString().equalsIgnoreCase("true")) {
					l1.add(conexaoUsuario.getResultSet().getArray(1).toString() + "*" + "T");	
				} else {
					l1.add(conexaoUsuario.getResultSet().getArray(1).toString() + "*" + "F");	
				}				
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar enunciados das questões do modelo de prova: " + erro);
		}
		Collections.shuffle(l1);
		for (int j = 0; j < l1.size(); j++) {	
			texto += "    " + letras[j] +" - "+l1.get(j).split(Pattern.quote("*"))[0] + "\r\n";
			if(l1.get(j).split(Pattern.quote("*"))[1].equals("T")){
				correta = letras[j];
			}
		}	
		a1[0] = correta;
		a1[1] = texto;
		return a1;
	}
		
	
	@Override
	public List<List<String>>  getGabaritoProva(String nome_prova) {

		List<List<String>>  lista = new ArrayList<>();
		String r = "";
		try {
			String sql = "select gabarito from prova where titulo = '"+ nome_prova+"';";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				r += (conexaoUsuario.getResultSet().getArray(1).toString());
				return extraiGabarito(r); 
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar gabaritos: " + erro);
		}
		return lista;
	}
		
	//ok
	@Override
	public String getIDAluno(String nome, String Id_usuario) {

		try {
			String sql = "select aluno_id from aluno where nome = '"+nome+"' and usuario_id = "+Id_usuario+";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return	conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar id do aluno: " + erro);
		}
		return "-1";
	}
		
	public List<String> getIDAlunosDaTurma(String turma_id) {

		List<String> listaListas = new ArrayList<>();
		try {
			String sql = "select distinct a.aluno_id from aluno a, aluno_turma t where t.turma_id = " + turma_id+"  and t.aluno_id = a.aluno_id;"; 
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.add(	conexaoUsuario.getResultSet().getArray(1).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar lista de id dos alunos da turma: " + erro);
		}
		return listaListas;
	}
	
	/**
	 * Busca o disciplina_id pelo nome da disciplina. Caso a disciplina seja 
	 * encontrada, retorna o seu id, caso contrario, salva a nova disciplina 
	 * e retorna seu id.
	 */
	public String getIDDisciplina(String nome) {

		try {
			String sql = "select disciplina_id from disciplina where nome = '" + nome+ "';";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return (conexaoUsuario.getResultSet().getArray(1).toString());
			}else{
				String sql_maxID = "select max(disciplina_id) from disciplina;";
				conexaoUsuario.executaConsulta(sql_maxID);
				if (conexaoUsuario.getResultSet().next()) {
					int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1;
					String sql_nova_instit = "insert into DISCIPLINA values ('"+nome+"')";
					conexaoUsuario.executaUpdate(sql_nova_instit);
					System.out.println("Nova disciplina salva: " + nome + " - " + id);
					return String.valueOf(id);
				}
			} 
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar a disciplina "+ nome +" : " + erro);
			return "-1";
		}
		System.out.println("Disciplina  "+ nome +" não encontrada!");
		return "-1";
	}
	
	/**
	 * Busca o instituicao_id pelo nome da instituicao. Caso a intituicao seja 
	 * encontrada, retorna o seu id, caso contrario, salva a nova instituicao 
	 * e retorna seu id.
	 */
	@Override
	public String getIDIntituicao(String nome, String Id_usuario) {


		try {

			String sql = "select instituicao_id from instituicao where nome = '" + nome+ "';";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return (conexaoUsuario.getResultSet().getArray(1).toString());
			}else{
				String sql_maxID = "select max(instituicao_id) from instituicao;";
				conexaoUsuario.executaConsulta(sql_maxID);
				if (conexaoUsuario.getResultSet().next()) {
					int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1;
					String sql_nova_instit = "insert into INSTITUICAO values ('"+nome+"','',-1,"+id+","+Id_usuario+")";
					conexaoUsuario.executaUpdate(sql_nova_instit);
					System.out.println("Nova instituição salva: " + nome + " - " + id);
					return String.valueOf(id);
				}
			} 
				
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar a instituição "+ nome +" : " + erro);
			return "-1";
		}
		System.out.println("Instituição  "+ nome +" instituição!");
		return "-1";
	}

	//ok
	@Override
	public String getIDModelo(String titulo, String Id_usuario) {

		try {
			String sql = "select modelodeprova_id from MODELODEPROVA where titulo = '"+titulo+"' and usuario_id = "+Id_usuario+";"; 
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar id do modelo de prova: " + erro);
		}
		return "-1";
	}

	//ok
	@Override
	public String getIDQuestao(String titulo, String Id_usuario) {

		try {
			String sql = "select questao_id from QUESTAO where titulo = '"+titulo+"' and usuario_id = "+Id_usuario+";"; 
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar id da questao: " + erro);
		}
		return "-1";
	}
	
	//ok
	/**
	 * Busca a turma_id pelo nome da turma. Caso a turma seja encontrada,
	 * retorna o seu id, caso contrario, salva a nova turma e retorna seu id.
	 */
	@Override
	public String getIDTurma(String nome, String Id_usuario) {

		try {

			String sql = "select turma_id from turma where nome = '"+nome+"' and usuario_id = "+Id_usuario+";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return (conexaoUsuario.getResultSet().getArray(1).toString());
			}else{
				String sql_maxID = "select max(turma_id) from turma;";
				conexaoUsuario.executaConsulta(sql_maxID);
				if (conexaoUsuario.getResultSet().next()) {
					int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1;
					String sql_nova_instit = "insert into TURMA values ("+Id_usuario+", -1, -1,'" + nome + "','2012')";
					conexaoUsuario.executaUpdate(sql_nova_instit);
					System.out.println("Nova turma salva: " + nome + " - " + id);
					return String.valueOf(id);
				}
			} 	
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar a turma "+ nome +" : " + erro);
			return "-1";
		}
		System.out.println("Turma  "+ nome +" não encontrada");
		return "-1";
	}
	
	//ok
	@Override
	public List<String> getIntituicao__(String nome, String Id_usuario) {

		List<String> lista = new ArrayList<String>();
		try {
			String sql = "select nome, cabecalho from instituicao where nome = '"+nome+"' and usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				lista.add(conexaoUsuario.getResultSet().getArray(1).toString());
				lista.add(conexaoUsuario.getResultSet().getArray(2).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar instituição: " + erro);
		}
		return lista;
	}
	
	public List<String> getLista(String tabela, String coluna, String Id_usuario) {

		List<String> lista = new ArrayList<>();
		try {
			String sql = "select " + coluna + " from " + tabela + " where usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				lista.add(conexaoUsuario.getResultSet().getArray(1).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar lista de objetos: " + erro);
		}
		return lista;
	}
	
	@Override
	public List<String> getModeloDeProva(String modelo_id) {


		List<String> lista = new ArrayList<>();
		try {//titulo, assunto, comentario
			String sql = "select * from modelodeprova where modelodeprova_id  = " + modelo_id + ";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				lista.add(conexaoUsuario.getResultSet().getArray(2).toString());
				lista.add(conexaoUsuario.getResultSet().getArray(3).toString());
				lista.add(conexaoUsuario.getResultSet().getArray(4).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar modelo de prova: " + erro);
		}
		return lista;
	}
	
	//ok
	@Override
	public List<List<String>> getModelosDeProva(String Id_usuario) {
		List<List<String>> listaListas = new ArrayList<>();
		for (int i = 0; i < 3; i++) {
			listaListas.add((List<String>) new ArrayList<String>());
		}
		try {
			String sql = "select * from modelodeprova where usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.get(0).add(	conexaoUsuario.getResultSet().getArray(2).toString()); // titulo
				listaListas.get(1).add(	conexaoUsuario.getResultSet().getArray(3).toString()); // assunto
				listaListas.get(2).add(	conexaoUsuario.getResultSet().getArray(4).toString()); // comentario
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar modelos de prova: " + erro);
		}
		return listaListas;
	}
	
	@Override
	public String getNextIDAluno() {

		try {
			String sql_maxID = "select max(aluno_id) from aluno;";
			conexaoUsuario.executaConsulta(sql_maxID);
			if (conexaoUsuario.getResultSet().next()) {
				return (Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString())) + 1)+"";
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar o proximo id do aluno: " + erro);
		}
		return "-1";
	}
	
	@Override
	public String getNextIDModelo() {

		try {
			conexaoUsuario.executaConsulta("select max(modelodeprova_id) from MODELODEPROVA;");
			if (conexaoUsuario.getResultSet().next()) {
				return (Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString())) + 1)+"";
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar o proximo id do modelo: " + erro);
		}
		return "-1";
	}
	
	@Override
	public String getNextIDQuestao() {

		try {
			conexaoUsuario.executaConsulta("select max(questao_id) from QUESTAO;");
			if (conexaoUsuario.getResultSet().next()) {
				return (Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString())) + 1)+"";
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar o proximo id da questao: " + erro);
		}
		return "-1";
	}
	
	public String getNomeAluno(String aluno_id, String Id_usuario) {

		
		try {
			String sql = "select nome from aluno where aluno_id = "+ aluno_id+ " and usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao nome do aluno: " + erro);
		}
		return "-";
	}
	
	@Override
	public List<String> getNomeAlunos(String Id_usuario) {

		List<String> lista = new ArrayList<String>();
		try {
			String sql = "select nome from aluno where usuario_id = " + Id_usuario + " ORDER BY nome;";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				lista.add(conexaoUsuario.getResultSet().getArray(1).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar alunos: " + erro);
		}
		return lista;
	}
	
	@Override
	public List<String> getNomeDisciplinas() {

		List<String> lista = new ArrayList<String>();
		try {
			String sql = "select nome from disciplina;";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				lista.add(conexaoUsuario.getResultSet().getArray(1).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar disciplinas: " + erro);
		}
		return lista;
	}
	
	@Override
	public List<String> getNomeIntituicoes(String Id_usuario) {

		List<String> lista = new ArrayList<String>();
		try {
			String sql = "select nome from instituicao where usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				lista.add(conexaoUsuario.getResultSet().getArray(1).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar instituições: " + erro);
		}
		return lista;
	}
	
	@Override
	public String getNomeUsuario(String Id_usuario) {

		try {
			String sql = "select nome from usuario where usuario_id = "+Id_usuario+";"; 
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return	conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar nome do usuário: " + erro);
		}
		return "";
	}

	@Override
	public List<String> getProvas(String turma_nome, String Id_usuario) {

		String id_turma = getIDTurma(turma_nome, Id_usuario);
		List<String> listaListas = new ArrayList<>();
		try {
			String sql = "select titulo from prova where turma_id = "+ id_turma+";"; 
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.add(	conexaoUsuario.getResultSet().getArray(1).toString());
				}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar Turmas: " + erro);
		}
		return listaListas;
	}
	
	@Override
	public ArrayList<ArrayList<String>> getProvasNotas(String nomeTurma, String subtituloProva, String Id_usuario) {

		String id_turma = getIDTurma(nomeTurma, Id_usuario);
		ArrayList<String> nota = new ArrayList<>();
		ArrayList<String> nome = new ArrayList<>();
		ArrayList<ArrayList<String>> lista = new ArrayList<>();
		try {
			String sql = "select a.nome, p.nota subtitulo from prova p, aluno a where p.turma_id = "+id_turma+" and p.subtitulo = '"+subtituloProva+"' and p.aluno_id = a.aluno_id ;";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				nome.add(	conexaoUsuario.getResultSet().getArray(1).toString());
				nota.add(	conexaoUsuario.getResultSet().getArray(2).toString());
				}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar nomes e notas da prova "+ subtituloProva +": " + erro);
		}
		lista.add(nome);
		lista.add(nota);
		return lista;
	}
	
	@Override
	public ArrayList<String> getProvasSubtitulos(String turmaNome, String Id_usuario) {

		String id_turma = getIDTurma(turmaNome, Id_usuario);
		ArrayList<String> lista = new ArrayList<>();
		try {
			String sql = "select distinct subtitulo from prova where turma_id = "+id_turma+" ;";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
					lista.add(	conexaoUsuario.getResultSet().getArray(1).toString());
				}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar subtitulos das provas da turma"+ turmaNome +": " + erro);
		}
		return lista;
	}
	
	@Override
	public List<String> getProvasSubtitulo(String turma_nome, String Id_usuario) {

		String id_turma = getIDTurma(turma_nome, Id_usuario);
		List<String> listaListas = new ArrayList<>();
		try {
			String sql = "select distinct subtitulo from prova where turma_id = "+ id_turma+";"; 
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.add(	conexaoUsuario.getResultSet().getArray(1).toString());
				}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar subtitulos das turmas: " + erro);
		}
		return listaListas;
	}
		
	@Override
	public String getQuestaoID(String titulo, String Id_usuario) {

		try {
			String sql = "select questao_id from questao where usuario_id = " + Id_usuario + " and titulo = '"+titulo+"';";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				return conexaoUsuario.getResultSet().getArray(1).toString();
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar id da questao: " + erro);
		}
		return "-1";
	}
	
	@Override
	public List<List<String>> getQuestoes(String Id_usuario) {

		List<List<String>> listaListas = new ArrayList<>();
		for (int i = 0; i < 5; i++) {
			listaListas.add((List<String>) new ArrayList<String>());
		}
		try {
			String sql = "select titulo, assunto, enunciado, tipo, dificuldade from questao where usuario_id = " + Id_usuario + ";";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.get(0).add(	conexaoUsuario.getResultSet().getArray(1).toString());
				listaListas.get(1).add(	conexaoUsuario.getResultSet().getArray(2).toString());
				listaListas.get(2).add( conexaoUsuario.getResultSet().getArray(3).toString());
				listaListas.get(3).add(	conexaoUsuario.getResultSet().getArray(4).toString());
				listaListas.get(4).add(	conexaoUsuario.getResultSet().getArray(5).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar questao: " + erro);
		}
		return listaListas;
	}

	@Override
	public List<List<String>> getQuestoesDoModelo(String modelo_id, String Id_usuario) {

		List<List<String>> listaListas = new ArrayList<>();
		for (int i = 0; i < 6; i++) {
			listaListas.add((List<String>) new ArrayList<String>());
		}
		try {
			String sql2 = "SELECT qmp.valor, q.titulo, q.assunto, q.tipo, q.enunciado, q.dificuldade FROM questao q, questaodomodelodeprova qmp WHERE q.questao_id = qmp.questao_id and qmp.modelodeprova_id = "+modelo_id;
			conexaoUsuario.executaConsulta(sql2);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.get(0).add(	conexaoUsuario.getResultSet().getArray(1).toString());
				listaListas.get(1).add(	conexaoUsuario.getResultSet().getArray(2).toString());
				listaListas.get(2).add( conexaoUsuario.getResultSet().getArray(3).toString());
				listaListas.get(3).add(	conexaoUsuario.getResultSet().getArray(4).toString());
				listaListas.get(4).add(	conexaoUsuario.getResultSet().getArray(5).toString());
				listaListas.get(5).add(	conexaoUsuario.getResultSet().getArray(6).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar questao do modelo: " + erro);
		}
		return listaListas;
	}
	
	@Override
	public List<List<String>> getQuestoesDoModeloDeProva(String modelo_id) {

		List<List<String>> lista = new ArrayList<>();
		for (int i = 0; i < 6; i++) {
			lista.add((List<String>) new ArrayList<String>());
		}		
		try {
			String sql = "SELECT qmp.valor, q.titulo, q.enunciado, q.assunto, q.tipo, q.dificuldade FROM questao q, questaodomodelodeprova qmp WHERE q.questao_id = qmp.questao_id and qmp.modelodeprova_id = "+modelo_id+";";
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				lista.get(0).add(	conexaoUsuario.getResultSet().getArray(1).toString());
				lista.get(1).add(	conexaoUsuario.getResultSet().getArray(2).toString());
				lista.get(2).add( 	conexaoUsuario.getResultSet().getArray(3).toString());
				lista.get(3).add(	conexaoUsuario.getResultSet().getArray(4).toString());
				lista.get(4).add(	conexaoUsuario.getResultSet().getArray(5).toString());
				lista.get(5).add(	conexaoUsuario.getResultSet().getArray(6).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar questao do modelo de prova: " + erro);
		}
		return lista;
	}

	@Override
	public ArrayList<ArrayList<String>> getRespostasEValoresGabarito(String tituloProva, String turma, String Id_usuario){

		ArrayList<ArrayList<String>> lista    = new ArrayList<>();
		ArrayList<String> corretas = new ArrayList<>();
		ArrayList<String> valores  = new ArrayList<>();
		String id_turma = getIDTurma(turma, Id_usuario);
		try {
			String sql = "select gabarito from prova where titulo = '"+tituloProva+"' and turma_id = "+id_turma+"";	
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) {
				String gabarito = conexaoUsuario.getResultSet().getArray(1).toString();
				String[] aux1 = gabarito.split(Pattern.quote("*")); // recupera cada questao com a alternativa correta e seu valor ex: aux[1] == "a^2.0"; aux[2] == "e^1.5"  
				for (int i = 1; i < aux1.length; i++) {
					corretas.add(aux1[i].split(Pattern.quote("^"))[0].toUpperCase());
					valores.add(aux1[i].split(Pattern.quote("^"))[1]);
				}
				lista.add(corretas);
				lista.add(valores);
				return lista;
			}			
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar gabarito da prova: " + erro);
		}
		return lista;
	}
	
	@Override
	public List<List<String>> getTurmas(String Id_usuario) {

		List<List<String>> listaListas = new ArrayList<>();
		for (int i = 0; i < 4; i++) {
			listaListas.add((List<String>) new ArrayList<String>());
		}
		try {
			String sql = "SELECT t.nome, d.nome, i.nome, t.ano FROM turma t, instituicao i, disciplina d WHERE t.instituicao_id = i.instituicao_id AND t.disciplina_id = d.disciplina_id AND t.usuario_id = " + Id_usuario + ";"; 
			conexaoUsuario.executaConsulta(sql);
			while (conexaoUsuario.getResultSet().next()) {
				listaListas.get(0).add(	conexaoUsuario.getResultSet().getArray(1).toString());
				listaListas.get(1).add(	conexaoUsuario.getResultSet().getArray(2).toString());
				listaListas.get(2).add( conexaoUsuario.getResultSet().getArray(3).toString());
				listaListas.get(3).add(	conexaoUsuario.getResultSet().getArray(4).toString());
			}
		} catch (Exception erro) {
			System.out.println("Erro ao recuperar Turmas: " + erro);
		}
		return listaListas;
	}
	
	public boolean gravarGabarito(String tituloProva, String aluno_id, String gabarito, String Id_usuario, String Login_usuario){
		String nome = getNomeAluno(aluno_id, Id_usuario);

		File dir1 = new File("MeusGabaritos");
		File dir2 = new File("MeusGabaritos\\"+Login_usuario);
		File dir3 = new File("MeusGabaritos\\"+Login_usuario+"\\"+Login_usuario+"_"+tituloProva);
		
		String t = nome + ".txt";
		File arq  = new File(dir3, t);
		if (!dir1.exists()) {
			dir1.mkdir();     
		}
		if (!dir2.exists()) {
			dir2.mkdir();     
		}
		if (!dir3.exists()) {
			dir3.mkdir();     
		}
		
		try {
			arq.createNewFile();
			FileWriter fileWriter = new FileWriter(arq, false);
			PrintWriter printWriter = new PrintWriter(fileWriter);
			printWriter.println(gabarito);
			printWriter.flush();
			printWriter.close();
			ZipDirectory.zipar("MeusGabaritos\\"+Login_usuario+"\\"+Login_usuario+"_"+tituloProva);
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
		
	}

	public boolean gravarProva(String tituloProva, String aluno_id, String texto, String Id_usuario, String Login_usuario){
		String nome = getNomeAluno(aluno_id, Id_usuario);

		File dir1 = new File("MinhasProvas");
		File dir2 = new File("MinhasProvas\\"+Login_usuario);
		File dir3 = new File("MinhasProvas\\"+Login_usuario+"\\"+Login_usuario+"_"+tituloProva);
		
		String t = nome + ".txt";
		File arq  = new File(dir3, t);
		if (!dir1.exists()) {
			dir1.mkdir();     
		}
		if (!dir2.exists()) {
			dir2.mkdir();     
		}
		if (!dir3.exists()) {
			dir3.mkdir();     
		}
		
		try {
			arq.createNewFile();
			FileWriter fileWriter = new FileWriter(arq, false);
			PrintWriter printWriter = new PrintWriter(fileWriter);
			printWriter.println(texto);
			printWriter.flush();
			printWriter.close();
			ZipDirectory.zipar("MinhasProvas\\"+Login_usuario+"\\"+Login_usuario+"_"+tituloProva);
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
		
	}

	@Override
	public String gravarResultados(String tituloProva, String texto, String Login_usuario){
		
		String arquivo = Login_usuario+"_Resultado_"+tituloProva.replace(" ", "") + ".txt";
		File arq  = new File(arquivo);
			
		try {
			arq.createNewFile();
			FileWriter fileWriter = new FileWriter(arq, false);
			PrintWriter printWriter = new PrintWriter(fileWriter);
			printWriter.println(texto);
			printWriter.flush();
			printWriter.close();
			return arquivo;
		} catch (IOException e) {
			e.printStackTrace();
			return "Erro ao imprimir resultados da prova";
		}
	}
	
	private String newFolhadeResposta() throws SQLException {

		String sql_maxFolhaID = "select max(folhaderesp_id) from folhaderesposta;";
		conexaoUsuario.executaConsulta(sql_maxFolhaID);
		if (conexaoUsuario.getResultSet().next()) {
			return Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1 +"";
		}
		return "-1";
	}
	private String newIDProva() throws SQLException {

		String sql_maxID = "select max(prova_id) from prova;";
		conexaoUsuario.executaConsulta(sql_maxID);
		if (conexaoUsuario.getResultSet().next()) {
			return (Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1 )+"";
		}
		return "-1";
	}
	
	@Override
	public String[] newProvaDoModelo(String titulo, String aluno_id, String modelo_id, String Id_usuario) {
		String nome = getNomeAluno(aluno_id, Id_usuario);
		List<String> lista = getEnunciadoQuestaoDoModeloDeProva(modelo_id);
		String texto = "\r\nAluno: "+nome+"\r\n"+lista.get(0);
		String gabarito = lista.get(1);
		String[] s = new String[]{texto,gabarito};
		return s;
	}
	

	@Override
	public Boolean salvarAlternativa(String questao_id, ArrayList<String> imagem_id, ArrayList<String> enunciado, ArrayList<String> correta) {

		try {
			conexaoUsuario.executaUpdate("delete from ALTERNATIVA where questao_id  = "+questao_id+";");		
			for (int i = 0; i < enunciado.size(); i++) {
				String sql = "insert into ALTERNATIVA values ("+questao_id+", "+imagem_id.get(i)+", '"+enunciado.get(i)+"', '"+correta.get(i)+"');";
				conexaoUsuario.executaUpdate(sql);	
			}
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar alternativas: " + erro);
			return false;
		}
	}

	@Override
	public Boolean salvarAlunos(String nome, String matricula, String instituicao, String Id_usuario) {

		try {
			String aluno_id = getNextIDAluno();
			String instituicao_id = getIDIntituicao(instituicao, Id_usuario);
			String sql = "select * from aluno a, instituicao_aluno i where a.nome = '"+nome+"'and instituicao_id = "+instituicao_id+" and matricula = '"+matricula+"' and a.usuario_id = "+Id_usuario+";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) { // o aluno já existe
				return false;
			} else {
				String sql1 = "insert into ALUNO values ("+Id_usuario+",'" + nome + "',"+aluno_id+" );";
				String sql2 = "insert into INSTITUICAO_ALUNO values ("+aluno_id+","+instituicao_id+",'"+matricula+"')";
				conexaoUsuario.executaUpdate(sql1);			
				conexaoUsuario.executaUpdate(sql2);
				return true;	
			}
			
		} catch (Exception erro) {
			System.out.println("Erro ao salvar aluno: " + erro);
			return false;
		}
	}
		
	@Override
	public Boolean salvarAlunosDaTurma(String turma, ArrayList<String> alunos, String Id_usuario) {

		ArrayList<String> alunosID = new ArrayList<>();
		String id_turma = getIDTurma(turma, Id_usuario);
		for (int i = 0; i < alunos.size(); i++) {
			alunosID.add(getIDAluno(alunos.get(i), Id_usuario));
		}
		try {
			conexaoUsuario.executaUpdate("delete from aluno_turma where turma_id = "+ id_turma+";");
				for (int i = 0; i < alunosID.size(); i++) {
				String sql = "insert into aluno_turma values("+alunosID.get(i)+","+id_turma+");";
				conexaoUsuario.executaUpdate(sql);	
			}
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar alunos da turma: " + erro);
			return false;
		}
	}

	@Override
	public void salvarInstituicao_Aluno(String instituicao_id, String matricula) {

		try {
			String sql_maxID = "select max(aluno_id) from aluno;";
			conexaoUsuario.executaConsulta(sql_maxID);
			if (conexaoUsuario.getResultSet().next()) {
				int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()));
				String sql = "insert into instituicao_aluno values ("+id+","+instituicao_id+",'"+matricula+"')";
				conexaoUsuario.executaUpdate(sql);
			}
		} catch (Exception erro) {
			System.out.println("Erro ao salvar instituição do aluno com matricula : " + erro);
		}
	}
	
	@Override
	public boolean salvarIntituicao(String nome, String cabecalho, String Id_usuario) {

		try {
			String sql_maxID = "select max(instituicao_id) from instituicao;";
			conexaoUsuario.executaConsulta(sql_maxID);
			if (conexaoUsuario.getResultSet().next()) {
				int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1;
				String sql_nova_instit = "insert into INSTITUICAO values ('"+nome+"','"+cabecalho+"',-1,"+id+","+Id_usuario+")";
				conexaoUsuario.executaUpdate(sql_nova_instit);
				System.out.println("Nova instituição salva: " + nome + " - " + id);
				return true;
			}				
		} catch (Exception erro) {
			System.out.println("Erro ao salvar nova instituição: " + erro);
			return false;
		}
		System.out.println("Erro ao salvar nova instituição.");
		return false;
	}
	
	@Override
	public Boolean salvarModeDeProva(String titulo, String assunto, String comentario, String modelo_id, String Id_usuario) {

		try {
			String sql = "insert into MODELODEPROVA values ("+Id_usuario+",'" + titulo + "','"+ assunto + "','" + comentario + "',"+modelo_id+");";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar modelo de prova: " + erro);
			return false;
		}
	}
	
	@Override
	public Boolean salvarNotaDaProva(String tituloProva, String nota) {

		try {
			String sql = "update prova set nota = '"+nota+"' where titulo = '"+tituloProva+"';";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar nota da prova: " + erro);
			return false;
		}
	}
    
	@Override
	public String salvarProva(String titulo, String texto_inicial, String nomeTurma, String tituloModeloDeProva, String Id_usuario, String Login_usuario) {

		try {
			String turma_id = getIDTurma(nomeTurma, Id_usuario);
			String modelo_id = getIDModelo(tituloModeloDeProva, Id_usuario);
			List<String> alunosID = getIDAlunosDaTurma(turma_id);
			for (int i = 0; i < alunosID.size(); i++) {
				String folha_id = newFolhadeResposta();
				String aluno_id = alunosID.get(i);
				String aluno_nome = getNomeAluno(aluno_id, Id_usuario);
				String prova_id = newIDProva();
				String[] modelo = newProvaDoModelo(titulo, aluno_id, modelo_id, Id_usuario);
				String texto = texto_inicial + modelo[0];
				String gabarito = modelo[1];
				gravarProva(titulo,aluno_id, texto, Id_usuario, Login_usuario);
				
				String sql1 = "insert into folhaderesposta values ("+aluno_id+", -1,"+folha_id+")";
				String sql2 = "insert into PROVA values ("+turma_id+", "+modelo_id+", '"+titulo+ " - " + aluno_nome+"','"+gabarito+"',"+prova_id+", "+aluno_id+", "+folha_id+",'0.0', '"+titulo+"')";
				conexaoUsuario.executaUpdate(sql1);
				conexaoUsuario.executaUpdate(sql2);
				
			}
			return "";
			 
		} catch (Exception erro) {
			System.out.println("Erro ao salvar a prova "+ titulo +" : " + erro);
			return "";
		}
	}

	@Override
	public Boolean salvarQuestao(String titulo, String assunto,	String enunciado, String dificuldade, String tipo, String imagem, String Id_usuario) {

		 try {
			String sql = "insert into QUESTAO values ("+Id_usuario+", -1, -1,'" + titulo + "','"	+ assunto + "','" + enunciado + "','" + tipo + "','"+ dificuldade + "');";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar questao: " + erro);
			return false;
		}
	}
	
	@Override
	public Boolean salvarQuestao(String titulo, String assunto,	String enunciado, String dificuldade, String tipo, String imagem, String questaoID, String Id_usuario) {

		 try {
			String sql = "insert into QUESTAO values ("+Id_usuario+", -1, -1,'" + titulo + "','"	+ assunto + "','" + enunciado + "','" + tipo + "','"+ dificuldade + "',"+questaoID+");";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar questao: " + erro);
			return false;
		}
	}
	
	@Override
	public Boolean salvarQuestaoNoModeloProva(String questao_id, String modelo_id, String valor) {

		try {
			String sql = "insert into questaodomodelodeprova values("+questao_id+", "+ modelo_id+", '" + valor+ "');";
			conexaoUsuario.executaUpdate(sql);
			return true;

		} catch (Exception erro) {
			System.out.println("Erro ao adicionar questão: " + erro);
			return false;
		}
	}
	
	@Override
	public Boolean salvarTurma( String instituicao, String disciplina, String nome, String ano, ArrayList<String> listaAlunos, String Id_usuario) {

		String instituicao_id = getIDIntituicao(instituicao, Id_usuario);
		String disciplina_id = getIDDisciplina(disciplina);
		String sql_maxID = "select max(turma_id) from turma;";
		try {
			conexaoUsuario.executaConsulta(sql_maxID);
			
			if (conexaoUsuario.getResultSet().next()) {
				int id = Integer.valueOf((conexaoUsuario.getResultSet().getArray(1).toString()))+1; 
				String sql = "insert into TURMA values ("+Id_usuario+", "+instituicao_id+", "+disciplina_id+",'" + nome + "','2012', "+id+")";
				conexaoUsuario.executaUpdate(sql);
				salvarAlunosDaTurma(nome, listaAlunos, Id_usuario);
				return true;
			}
			return false;
		} catch (Exception erro) {
			System.out.println("Erro ao salvar turma: " + erro);
			return false;
		}
	}
	 
	@Override
	public Boolean updateAluno(String nomeAntigo, String matriculaAntiga, String instituicaoAntiga, String nome, String matricula, String instituicao, String Id_usuario) {

		try {
			String sql = "select * from aluno a, instituicao_aluno i where a.nome = '"+nome+"'and instituicao_id = "+getIDIntituicao(instituicao, Id_usuario)+" and matricula = '"+matricula+"' and a.usuario_id = "+Id_usuario+";";
			conexaoUsuario.executaConsulta(sql);
			if (conexaoUsuario.getResultSet().next()) { // o aluno já existe
				return false;
			} else {
				String sql1 = "update ALUNO set nome = '"+nome+"' where aluno_id = "+getIDAluno(nomeAntigo, Id_usuario)+";" + "update INSTITUICAO_ALUNO set instituicao_id = "+	getIDIntituicao(instituicao, Id_usuario)+" ,matricula= '"+matricula+"' " + "where aluno_id = "+getIDAluno(nomeAntigo, Id_usuario)+";";
				conexaoUsuario.executaUpdate(sql1);
				return true;	
			}
			
		} catch (Exception erro) {
			System.out.println("Erro ao editar aluno: " + erro);
			return false;
		}
	}

	@Override
	public Boolean updateInstituicao(String nomeAntigo, String nome, String cabecalho, String Id_usuario) {

		try {
			String sql = "update INSTITUICAO set nome = '"+nome+"', cabecalho = '"+cabecalho+"' where instituicao_id = "+getIDIntituicao(nomeAntigo, Id_usuario)+";";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao editar instituicao: " + erro);
			return false;
		}
	}
	@Override
	public Boolean updateModeDeProva(String tituloAntigo, String titulo,
			String assunto, String comentario) {

		try {
			String sql = "update MODELODEPROVA set titulo='" + titulo+ "',assunto='" + assunto + "',comentario='" + comentario+ "' where titulo ='" + tituloAntigo + "'";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao editar modelo de prova: " + erro);
			return false;
		}
	}
	
	@Override
	public Boolean updateQuestao(String tituloAntigo, String titulo, String assunto, String enunciado, String dificuldade, String tipo, String imagem, String Id_usuario) {

		try {
			String sql = "update QUESTAO set titulo='" + titulo + "',enunciado='" + enunciado + "',assunto='" + assunto + "',tipo='" + tipo + "',dificuldade='" + dificuldade + "' where titulo ='" + tituloAntigo + "' and usuario_id = " + Id_usuario + "";
			conexaoUsuario.executaUpdate(sql);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao editar questao: " + erro);
			return false;
		}
	}
		
	@Override
	public Boolean updateTurma(String nomeAntigo, String nome, String instituicao, String disciplina, String ano, ArrayList<String> listaAlunos, String Id_usuario) {

		String instituicao_id = getIDIntituicao(instituicao, Id_usuario);
		String disciplina_id = getIDDisciplina(disciplina);
		try {
			String sql = "update TURMA set nome='" + nome + "',instituicao_id='" + instituicao_id + "',disciplina_id='" + disciplina_id + "',ano='" + ano + "' where nome ='" + nomeAntigo + "' and usuario_id = " + Id_usuario + "";
			conexaoUsuario.executaUpdate(sql);
			salvarAlunosDaTurma(nome, listaAlunos, Id_usuario);
			return true;
		} catch (Exception erro) {
			System.out.println("Erro ao editar turma: " + erro);
			return false;
		}
	}
	

	@Override
	public Boolean updateUsuario(String nome, String login, String email, String senhaNova, String senhaAntiga, String Id_usuario) {
		Conexao conexaoUsuario = Conexao.getNewConexao();
		try {
			String sql1 = "select * from usuario where usuario_id = "+Id_usuario+" and senha = '"+senhaAntiga+"'";
			conexaoUsuario.executaConsulta(sql1);
			if (conexaoUsuario.getResultSet().next()) {
				String sql = "update usuario set nome = '"+nome+"', login = '"+login+"', senha = '"+senhaNova+"', email = '"+email+"' where usuario_id = "+Id_usuario+" and senha = '"+senhaAntiga+"';";
				conexaoUsuario.executaUpdate(sql);
				return true;
			}
			return false;
		} catch (Exception erro) {
			System.out.println("Erro ao configurar usuário: " + erro);
			return false;
		}
	}


}

//insert into prova values (23 , 1, 'Nova prova','',4, 2, -1,'2')

//public Boolean salvarTurma(String nometurma, String modelo_id) {
//	mode
//	try {
//		String sql = "insert into questaodomodelodeprova values("+questao_id+", "+ modelo_id+", '" + valor+ "');";
//		System.out.println(sql);
//		conexaoUsuario.executaUpdate(sql);
//		return true;
//
//	} catch (Exception erro) {
//		System.out.println("Erro ao adicionar questão: " + erro);
//		return false;
//	}
//}

// editar alunos da turma                              - ok
// buscar aluno da turma							   - ok
// add aluno_turma                                     - ok
// sugestao de disciplinas							   - ok 
// sugestao de intituicoes							   - ok
// criar, editar e exibir turma						   - ok   
// quando adicionar uma nova intituicao, atual lista   - ok 
// adicionar questao do modelo de prova                - ok    